
var Buffer = require('buffer').Buffer;

export class OAuth2Token{

    constructor(token) {
        this._token = token;
        // resourceIds
        Object.defineProperty(this, "resourceIds",{
            configurable: false,
            get: () => {
                return this._token.resourceIds;
            }
        });
        // scopes
        Object.defineProperty(this, "scopes",{
            configurable: false,
            get: () => {
                return this._token.scopes;
            }
        });
        // userId
        Object.defineProperty(this, "userId",{
            configurable: false,
            get: () => {
                return this._token.userId;
            }
        });
        // tokenId
        Object.defineProperty(this, "tokenId",{
            configurable: false,
            get: () => {
                return this._token.tokenId;
            }
        });
        // authorities
        Object.defineProperty(this, "authorities",{
            configurable: false,
            get: () => {
                return this._token.authorities;
            }
        });
        // clientId
        Object.defineProperty(this, "clientId",{
            configurable: false,
            get: () => {
                return this._token.clientId;
            }
        });
        // expires
        Object.defineProperty(this, "expires",{
            configurable: false,
            get: () => {
                return this._token.expires      ;
            }
        });
    }

    // 获取当前 token 所拥有的权限
    _getAuthority() {
        return this._token && this._token.authorities;
    }

    // 判断是否拥有某个角色,判断的角色为undefined或null或空字符串时，认为拥有角色
    hasRole(role) {
        if (!role) {
            return true;
        }
        return this.hasAnyRole(role);
    }

    // 是否拥有其中一个角色
    hasAnyRole() {
        var length = arguments.length;
        // 没有token信息时
        if (!this._token) {
            return true;
        }
        var authorities = this._getAuthority();
        // 没有权限信息时
        if (!authorities || !Array.isArray(authorities)) {
            return false;
        }
        for (var i = 0; i < length; i++) {
            //当参数中有一个角色在权限信息中就返回true
            if (authorities.includes("ROLE_" + arguments[i])) {
                return true;
            }
        }
        return false;
    }

    // 是否同时拥有所有角色
    hasAndRole() {
        var length = arguments.length;
        // 没有token信息时
        if (!this._token) {
            return false;
        }
        var authorities = this._getAuthority();
        // 没有权限信息时
        if (!authorities) {
            return false;
        }
        for (var i = 0; i < length; i++) {
            // 当参数中有一个角色没在权限信息中就返回false
            if (!authorities.includes("ROLE_" + arguments[i])) {
                return false;
            }
        }
        // 当参数中所有角色都在权限信息中就返回true
        return true;
    }

    // 判断是否拥有某个权限,判断的权限为undefined或null或空字符串时，认为拥有权限
    hasAuthority(authority) {
        if (!authority) {
            return true;
        }
        return this.hasAnyAuthority(authority);
    }

    // 是否拥有其中一个权限
    hasAnyAuthority() {
        var length = arguments.length;
        // 没有token信息时
        if (!this._token) {
            return false;
        }
        var authorities = this._getAuthority();
        // 没有权限信息时
        if (!authorities) {
            return false;
        }
        for (var i = 0; i < length; i++) {
            //当参数中有一个角色在权限信息中就返回true
            if (authorities.includes(arguments[i])) {
                return true;
            }
        }
        return false;
    }

    // 是否同时拥有所有权限
    hasAndAuthority() {
        var length = arguments.length;
        // 没有token信息时
        if (!this._token) {
            return false;
        }
        var authorities = this._getAuthority();
        // 没有权限信息时
        if (!authorities) {
            return false;
        }
        for (var i = 0; i < length; i++) {
            // 当参数中有一个角色没在权限信息中就返回false
            if (!authorities.includes(arguments[i])) {
                return false;
            }
        }
        // 当参数中所有权限都在权限信息中就返回true
        return true;
    }

    // 表示是否通过password或mobile模式获取的token。
    isUser() {
        if (this._token && this._token.userId) {
            return true;
        }
        return false;
    }

    // 表示是否通过client模式获取的token。
    isClient() {
        return !this.isUser();
    }
}

OAuth2Token.parse = (tokenStr) => {
    // var accessToken = this.token && this.token.data && this.token.data.access_token;

    if(!tokenStr) {
        return
    }

    // 获取权限信息部分
    // var tempStr = tokenStr.substring(startIndex + 1, endIndex);
    var tokenStrArr = tokenStr.split(".");
    if(tokenStrArr == null || tokenStrArr.length != 3){
        return null;
    }
    var tempStr = tokenStrArr[1];
    // 解码权限信息
    // var valueStr = new Buffer(tempStr, 'base64').toString();
    var valueStr = Buffer.from(tempStr,'base64').toString()
    var v = JSON.parse(valueStr);

    //构建 token 对象
    return new OAuth2Token({
        resourceIds:v.aud,
        scopes: v.scope,
        userId: v.user_name,
        tokenId: v.jti,
        authorities: v.authorities,
        clientId: v.client_id,
        expires: new Date(v.exp * 1000),
    })
}